home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_textwrap.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  16KB  |  532 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import unittest
  5. from test import test_support
  6. from textwrap import TextWrapper, wrap, fill, dedent
  7.  
  8. class BaseTestCase(unittest.TestCase):
  9.     '''Parent class with utility methods for textwrap tests.'''
  10.     
  11.     def show(self, textin):
  12.         if isinstance(textin, list):
  13.             result = []
  14.             for i in range(len(textin)):
  15.                 result.append('  %d: %r' % (i, textin[i]))
  16.             
  17.             result = '\n'.join(result)
  18.         elif isinstance(textin, basestring):
  19.             result = '  %s\n' % repr(textin)
  20.         
  21.         return result
  22.  
  23.     
  24.     def check(self, result, expect):
  25.         self.assertEquals(result, expect, 'expected:\n%s\nbut got:\n%s' % (self.show(expect), self.show(result)))
  26.  
  27.     
  28.     def check_wrap(self, text, width, expect, **kwargs):
  29.         result = wrap(text, width, **kwargs)
  30.         self.check(result, expect)
  31.  
  32.     
  33.     def check_split(self, text, expect):
  34.         result = self.wrapper._split(text)
  35.         self.assertEquals(result, expect, '\nexpected %r\nbut got  %r' % (expect, result))
  36.  
  37.  
  38.  
  39. class WrapTestCase(BaseTestCase):
  40.     
  41.     def setUp(self):
  42.         self.wrapper = TextWrapper(width = 45)
  43.  
  44.     
  45.     def test_simple(self):
  46.         text = "Hello there, how are you this fine day?  I'm glad to hear it!"
  47.         self.check_wrap(text, 12, [
  48.             'Hello there,',
  49.             'how are you',
  50.             'this fine',
  51.             "day?  I'm",
  52.             'glad to hear',
  53.             'it!'])
  54.         self.check_wrap(text, 42, [
  55.             'Hello there, how are you this fine day?',
  56.             "I'm glad to hear it!"])
  57.         self.check_wrap(text, 80, [
  58.             text])
  59.  
  60.     
  61.     def test_whitespace(self):
  62.         text = 'This is a paragraph that already has\nline breaks.  But some of its lines are much longer than the others,\nso it needs to be wrapped.\nSome lines are \ttabbed too.\nWhat a mess!\n'
  63.         expect = [
  64.             'This is a paragraph that already has line',
  65.             'breaks.  But some of its lines are much',
  66.             'longer than the others, so it needs to be',
  67.             'wrapped.  Some lines are  tabbed too.  What a',
  68.             'mess!']
  69.         wrapper = TextWrapper(45, fix_sentence_endings = True)
  70.         result = wrapper.wrap(text)
  71.         self.check(result, expect)
  72.         result = wrapper.fill(text)
  73.         self.check(result, '\n'.join(expect))
  74.  
  75.     
  76.     def test_fix_sentence_endings(self):
  77.         wrapper = TextWrapper(60, fix_sentence_endings = True)
  78.         text = 'A short line. Note the single space.'
  79.         expect = [
  80.             'A short line.  Note the single space.']
  81.         self.check(wrapper.wrap(text), expect)
  82.         text = 'Well, Doctor? What do you think?'
  83.         expect = [
  84.             'Well, Doctor?  What do you think?']
  85.         self.check(wrapper.wrap(text), expect)
  86.         text = 'Well, Doctor?\nWhat do you think?'
  87.         self.check(wrapper.wrap(text), expect)
  88.         text = 'I say, chaps! Anyone for "tennis?"\nHmmph!'
  89.         expect = [
  90.             'I say, chaps!  Anyone for "tennis?"  Hmmph!']
  91.         self.check(wrapper.wrap(text), expect)
  92.         wrapper.width = 20
  93.         expect = [
  94.             'I say, chaps!',
  95.             'Anyone for "tennis?"',
  96.             'Hmmph!']
  97.         self.check(wrapper.wrap(text), expect)
  98.         text = 'And she said, "Go to hell!"\nCan you believe that?'
  99.         expect = [
  100.             'And she said, "Go to',
  101.             'hell!"  Can you',
  102.             'believe that?']
  103.         self.check(wrapper.wrap(text), expect)
  104.         wrapper.width = 60
  105.         expect = [
  106.             'And she said, "Go to hell!"  Can you believe that?']
  107.         self.check(wrapper.wrap(text), expect)
  108.  
  109.     
  110.     def test_wrap_short(self):
  111.         text = 'This is a\nshort paragraph.'
  112.         self.check_wrap(text, 20, [
  113.             'This is a short',
  114.             'paragraph.'])
  115.         self.check_wrap(text, 40, [
  116.             'This is a short paragraph.'])
  117.  
  118.     
  119.     def test_wrap_short_1line(self):
  120.         text = 'This is a short line.'
  121.         self.check_wrap(text, 30, [
  122.             'This is a short line.'])
  123.         self.check_wrap(text, 30, [
  124.             '(1) This is a short line.'], initial_indent = '(1) ')
  125.  
  126.     
  127.     def test_hyphenated(self):
  128.         text = "this-is-a-useful-feature-for-reformatting-posts-from-tim-peters'ly"
  129.         self.check_wrap(text, 40, [
  130.             'this-is-a-useful-feature-for-',
  131.             "reformatting-posts-from-tim-peters'ly"])
  132.         self.check_wrap(text, 41, [
  133.             'this-is-a-useful-feature-for-',
  134.             "reformatting-posts-from-tim-peters'ly"])
  135.         self.check_wrap(text, 42, [
  136.             'this-is-a-useful-feature-for-reformatting-',
  137.             "posts-from-tim-peters'ly"])
  138.  
  139.     
  140.     def test_hyphenated_numbers(self):
  141.         text = 'Python 1.0.0 was released on 1994-01-26.  Python 1.0.1 was\nreleased on 1994-02-15.'
  142.         self.check_wrap(text, 30, [
  143.             'Python 1.0.0 was released on',
  144.             '1994-01-26.  Python 1.0.1 was',
  145.             'released on 1994-02-15.'])
  146.         self.check_wrap(text, 40, [
  147.             'Python 1.0.0 was released on 1994-01-26.',
  148.             'Python 1.0.1 was released on 1994-02-15.'])
  149.         text = 'I do all my shopping at 7-11.'
  150.         self.check_wrap(text, 25, [
  151.             'I do all my shopping at',
  152.             '7-11.'])
  153.         self.check_wrap(text, 27, [
  154.             'I do all my shopping at',
  155.             '7-11.'])
  156.         self.check_wrap(text, 29, [
  157.             'I do all my shopping at 7-11.'])
  158.  
  159.     
  160.     def test_em_dash(self):
  161.         text = 'Em-dashes should be written -- thus.'
  162.         self.check_wrap(text, 25, [
  163.             'Em-dashes should be',
  164.             'written -- thus.'])
  165.         self.check_wrap(text, 29, [
  166.             'Em-dashes should be written',
  167.             '-- thus.'])
  168.         expect = [
  169.             'Em-dashes should be written --',
  170.             'thus.']
  171.         self.check_wrap(text, 30, expect)
  172.         self.check_wrap(text, 35, expect)
  173.         self.check_wrap(text, 36, [
  174.             'Em-dashes should be written -- thus.'])
  175.         text = 'You can also do--this or even---this.'
  176.         expect = [
  177.             'You can also do',
  178.             '--this or even',
  179.             '---this.']
  180.         self.check_wrap(text, 15, expect)
  181.         self.check_wrap(text, 16, expect)
  182.         expect = [
  183.             'You can also do--',
  184.             'this or even---',
  185.             'this.']
  186.         self.check_wrap(text, 17, expect)
  187.         self.check_wrap(text, 19, expect)
  188.         expect = [
  189.             'You can also do--this or even',
  190.             '---this.']
  191.         self.check_wrap(text, 29, expect)
  192.         self.check_wrap(text, 31, expect)
  193.         expect = [
  194.             'You can also do--this or even---',
  195.             'this.']
  196.         self.check_wrap(text, 32, expect)
  197.         self.check_wrap(text, 35, expect)
  198.         text = "Here's an -- em-dash and--here's another---and another!"
  199.         expect = [
  200.             "Here's",
  201.             ' ',
  202.             'an',
  203.             ' ',
  204.             '--',
  205.             ' ',
  206.             'em-',
  207.             'dash',
  208.             ' ',
  209.             'and',
  210.             '--',
  211.             "here's",
  212.             ' ',
  213.             'another',
  214.             '---',
  215.             'and',
  216.             ' ',
  217.             'another!']
  218.         self.check_split(text, expect)
  219.         text = 'and then--bam!--he was gone'
  220.         expect = [
  221.             'and',
  222.             ' ',
  223.             'then',
  224.             '--',
  225.             'bam!',
  226.             '--',
  227.             'he',
  228.             ' ',
  229.             'was',
  230.             ' ',
  231.             'gone']
  232.         self.check_split(text, expect)
  233.  
  234.     
  235.     def test_unix_options(self):
  236.         text = 'You should use the -n option, or --dry-run in its long form.'
  237.         self.check_wrap(text, 20, [
  238.             'You should use the',
  239.             '-n option, or --dry-',
  240.             'run in its long',
  241.             'form.'])
  242.         self.check_wrap(text, 21, [
  243.             'You should use the -n',
  244.             'option, or --dry-run',
  245.             'in its long form.'])
  246.         expect = [
  247.             'You should use the -n option, or',
  248.             '--dry-run in its long form.']
  249.         self.check_wrap(text, 32, expect)
  250.         self.check_wrap(text, 34, expect)
  251.         self.check_wrap(text, 35, expect)
  252.         self.check_wrap(text, 38, expect)
  253.         expect = [
  254.             'You should use the -n option, or --dry-',
  255.             'run in its long form.']
  256.         self.check_wrap(text, 39, expect)
  257.         self.check_wrap(text, 41, expect)
  258.         expect = [
  259.             'You should use the -n option, or --dry-run',
  260.             'in its long form.']
  261.         self.check_wrap(text, 42, expect)
  262.         text = 'the -n option, or --dry-run or --dryrun'
  263.         expect = [
  264.             'the',
  265.             ' ',
  266.             '-n',
  267.             ' ',
  268.             'option,',
  269.             ' ',
  270.             'or',
  271.             ' ',
  272.             '--dry-',
  273.             'run',
  274.             ' ',
  275.             'or',
  276.             ' ',
  277.             '--dryrun']
  278.         self.check_split(text, expect)
  279.  
  280.     
  281.     def test_funky_hyphens(self):
  282.         self.check_split('what the--hey!', [
  283.             'what',
  284.             ' ',
  285.             'the',
  286.             '--',
  287.             'hey!'])
  288.         self.check_split('what the--', [
  289.             'what',
  290.             ' ',
  291.             'the--'])
  292.         self.check_split('what the--.', [
  293.             'what',
  294.             ' ',
  295.             'the--.'])
  296.         self.check_split('--text--.', [
  297.             '--text--.'])
  298.         self.check_split('--option', [
  299.             '--option'])
  300.         self.check_split('--option-opt', [
  301.             '--option-',
  302.             'opt'])
  303.         self.check_split('foo --option-opt bar', [
  304.             'foo',
  305.             ' ',
  306.             '--option-',
  307.             'opt',
  308.             ' ',
  309.             'bar'])
  310.  
  311.     
  312.     def test_punct_hyphens(self):
  313.         self.check_split("the 'wibble-wobble' widget", [
  314.             'the',
  315.             ' ',
  316.             "'wibble-",
  317.             "wobble'",
  318.             ' ',
  319.             'widget'])
  320.         self.check_split('the "wibble-wobble" widget', [
  321.             'the',
  322.             ' ',
  323.             '"wibble-',
  324.             'wobble"',
  325.             ' ',
  326.             'widget'])
  327.         self.check_split('the (wibble-wobble) widget', [
  328.             'the',
  329.             ' ',
  330.             '(wibble-',
  331.             'wobble)',
  332.             ' ',
  333.             'widget'])
  334.         self.check_split("the ['wibble-wobble'] widget", [
  335.             'the',
  336.             ' ',
  337.             "['wibble-",
  338.             "wobble']",
  339.             ' ',
  340.             'widget'])
  341.  
  342.     
  343.     def test_funky_parens(self):
  344.         self.check_split('foo (--option) bar', [
  345.             'foo',
  346.             ' ',
  347.             '(--option)',
  348.             ' ',
  349.             'bar'])
  350.         self.check_split('foo (bar) baz', [
  351.             'foo',
  352.             ' ',
  353.             '(bar)',
  354.             ' ',
  355.             'baz'])
  356.         self.check_split('blah (ding dong), wubba', [
  357.             'blah',
  358.             ' ',
  359.             '(ding',
  360.             ' ',
  361.             'dong),',
  362.             ' ',
  363.             'wubba'])
  364.  
  365.     
  366.     def test_initial_whitespace(self):
  367.         text = ' This is a sentence with leading whitespace.'
  368.         self.check_wrap(text, 50, [
  369.             ' This is a sentence with leading whitespace.'])
  370.         self.check_wrap(text, 30, [
  371.             ' This is a sentence with',
  372.             'leading whitespace.'])
  373.  
  374.     
  375.     def test_unicode(self):
  376.         text = u'Hello there, how are you today?'
  377.         self.check_wrap(text, 50, [
  378.             u'Hello there, how are you today?'])
  379.         self.check_wrap(text, 20, [
  380.             u'Hello there, how are',
  381.             'you today?'])
  382.         olines = self.wrapper.wrap(text)
  383.         otext = self.wrapper.fill(text)
  384.  
  385.     
  386.     def test_split(self):
  387.         text = 'Hello there -- you goof-ball, use the -b option!'
  388.         result = self.wrapper._split(text)
  389.         self.check(result, [
  390.             'Hello',
  391.             ' ',
  392.             'there',
  393.             ' ',
  394.             '--',
  395.             ' ',
  396.             'you',
  397.             ' ',
  398.             'goof-',
  399.             'ball,',
  400.             ' ',
  401.             'use',
  402.             ' ',
  403.             'the',
  404.             ' ',
  405.             '-b',
  406.             ' ',
  407.             'option!'])
  408.  
  409.     
  410.     def test_bad_width(self):
  411.         text = "Whatever, it doesn't matter."
  412.         self.assertRaises(ValueError, wrap, text, 0)
  413.         self.assertRaises(ValueError, wrap, text, -1)
  414.  
  415.  
  416.  
  417. class LongWordTestCase(BaseTestCase):
  418.     
  419.     def setUp(self):
  420.         self.wrapper = TextWrapper()
  421.         self.text = 'Did you say "supercalifragilisticexpialidocious?"\nHow *do* you spell that odd word, anyways?\n'
  422.  
  423.     
  424.     def test_break_long(self):
  425.         self.check_wrap(self.text, 30, [
  426.             'Did you say "supercalifragilis',
  427.             'ticexpialidocious?" How *do*',
  428.             'you spell that odd word,',
  429.             'anyways?'])
  430.         self.check_wrap(self.text, 50, [
  431.             'Did you say "supercalifragilisticexpialidocious?"',
  432.             'How *do* you spell that odd word, anyways?'])
  433.         self.check_wrap('-' * 10 + 'hello', 10, [
  434.             '----------',
  435.             '               h',
  436.             '               e',
  437.             '               l',
  438.             '               l',
  439.             '               o'], subsequent_indent = ' ' * 15)
  440.  
  441.     
  442.     def test_nobreak_long(self):
  443.         self.wrapper.break_long_words = 0
  444.         self.wrapper.width = 30
  445.         expect = [
  446.             'Did you say',
  447.             '"supercalifragilisticexpialidocious?"',
  448.             'How *do* you spell that odd',
  449.             'word, anyways?']
  450.         result = self.wrapper.wrap(self.text)
  451.         self.check(result, expect)
  452.         result = wrap(self.text, width = 30, break_long_words = 0)
  453.         self.check(result, expect)
  454.  
  455.  
  456.  
  457. class IndentTestCases(BaseTestCase):
  458.     
  459.     def setUp(self):
  460.         self.text = 'This paragraph will be filled, first without any indentation,\nand then with some (including a hanging indent).'
  461.  
  462.     
  463.     def test_fill(self):
  464.         expect = 'This paragraph will be filled, first\nwithout any indentation, and then with\nsome (including a hanging indent).'
  465.         result = fill(self.text, 40)
  466.         self.check(result, expect)
  467.  
  468.     
  469.     def test_initial_indent(self):
  470.         expect = [
  471.             '     This paragraph will be filled,',
  472.             'first without any indentation, and then',
  473.             'with some (including a hanging indent).']
  474.         result = wrap(self.text, 40, initial_indent = '     ')
  475.         self.check(result, expect)
  476.         expect = '\n'.join(expect)
  477.         result = fill(self.text, 40, initial_indent = '     ')
  478.         self.check(result, expect)
  479.  
  480.     
  481.     def test_subsequent_indent(self):
  482.         expect = '  * This paragraph will be filled, first\n    without any indentation, and then\n    with some (including a hanging\n    indent).'
  483.         result = fill(self.text, 40, initial_indent = '  * ', subsequent_indent = '    ')
  484.         self.check(result, expect)
  485.  
  486.  
  487.  
  488. class DedentTestCase(unittest.TestCase):
  489.     
  490.     def test_dedent_nomargin(self):
  491.         text = "Hello there.\nHow are you?\nOh good, I'm glad."
  492.         self.assertEquals(dedent(text), text)
  493.         text = 'Hello there.\n\nBoo!'
  494.         self.assertEquals(dedent(text), text)
  495.         text = 'Hello there.\n  This is indented.'
  496.         self.assertEquals(dedent(text), text)
  497.         text = 'Hello there.\n\n  Boo!\n'
  498.         self.assertEquals(dedent(text), text)
  499.  
  500.     
  501.     def test_dedent_even(self):
  502.         text = '  Hello there.\n  How are ya?\n  Oh good.'
  503.         expect = 'Hello there.\nHow are ya?\nOh good.'
  504.         self.assertEquals(dedent(text), expect)
  505.         text = '  Hello there.\n\n  How are ya?\n  Oh good.\n'
  506.         expect = 'Hello there.\n\nHow are ya?\nOh good.\n'
  507.         self.assertEquals(dedent(text), expect)
  508.         text = '  Hello there.\n  \n  How are ya?\n  Oh good.\n'
  509.         expect = 'Hello there.\n\nHow are ya?\nOh good.\n'
  510.         self.assertEquals(dedent(text), expect)
  511.  
  512.     
  513.     def test_dedent_uneven(self):
  514.         text = '        def foo():\n            while 1:\n                return foo\n        '
  515.         expect = 'def foo():\n    while 1:\n        return foo\n'
  516.         self.assertEquals(dedent(text), expect)
  517.         text = '  Foo\n    Bar\n\n   Baz\n'
  518.         expect = 'Foo\n  Bar\n\n Baz\n'
  519.         self.assertEquals(dedent(text), expect)
  520.         text = '  Foo\n    Bar\n \n   Baz\n'
  521.         expect = 'Foo\n  Bar\n\n Baz\n'
  522.         self.assertEquals(dedent(text), expect)
  523.  
  524.  
  525.  
  526. def test_main():
  527.     test_support.run_unittest(WrapTestCase, LongWordTestCase, IndentTestCases, DedentTestCase)
  528.  
  529. if __name__ == '__main__':
  530.     test_main()
  531.  
  532.